Computer systems are collections of computer program parts, called modules, that employ physical and computational resources to convert inputs into desired outputs. Current technology provides several levels of support for system construction. For example, programming languages such as FORTRAN or COBOL allow a programmer to define the behavior of a single module, which is a part of a computer program that employs physical and computational resources to convert inputs into desired outputs. Existing operating systems provide facilities for allocating resources and directing inputs and outputs. In combination with languages and operating systems, programming environments allow the programmer to specify how individual modules should be combined to build the entire system. In systems supporting multiple languages for program specification, the programs are combined into modules by use of linkloaders with programs inside a module communicating either by sharing data (example Common in FORTRAN) or by subroutine calls (including subroutines such as Functions that return data to the caller). Such subroutine calls establish a master-slave relationship by virtue of which the calling program gives control to the called subroutine and also passes it data in the form of arguments that bind to formal parameters in the subroutine definition; termination of the caller terminates the called subroutine.
Programming environments provided with current operating systems permit only a limited number of ways for building modules and assembling modules into bigger modules or systems. Each of such existing environments or "frameworks" provides a restricted syntax for describing the ways to combine parts and transfer a component's output to another component as input. Although these frameworks embody a language for describing the desired componential structure and overall behavior of the system and provide an implementation mechanism that combines the behaviors of the components in a manner that yields the specified desired behavior of the new modules, certain disadvantages are inherent to them. For instance, in system development, different languages embody different problem-solving approaches and, as a result, are best suited to solving different kinds of problems. Consequently, system designers prefer one kind of language for mathematical problem-solving (e.g., FORTRAN), another for commercial problem-solving (e.g., COBOL), another for AI programming (e.g., LISP), another for graphics (e.g., SMALLTALK), another for conventional data flow programming (e.g., some type of data flow language), and yet another for cooperative expert systems (e.g., a blackboard language). It hence becomes desirable, when an overall system embodies subproblems of different kinds, to use distinctly appropriate languages for each subproblem. This objective cannot be achieved with conventional systems because such diverse languages (e.g., SMALLTALK and DATAFLOW) produce modules that are incapable of being composed and integrated.
Although conventional operating systems such as UNIX and the IBM System/370 do provide some means for composing and integrating modules into larger or composite modules by sequencing of individual modules, i.e., by ensuring that data produced during the execution of the module is made available to subsequently executing modules, a significant disadvantage is that modules developed for use in one system (such as UNIX) generally cannot be assembled with modules in a different system (such as the IBM System/370). The resulting modules are dependent upon the framework in which they are assembled and consequently cannot be combined in different frameworks. Current technology is incapable of developing a module to provide a specified functionality unless the functionality is specified in terms of the framework in which the module is to be used.
Similarly, existing techniques for passing data between modules in one framework do not apply to modules connected in another framework. For example, there is no way to connect to the program steps in the IBM System/370 framework with the pipe construct of UNIX, nor is there a way to make a program that reads file records process another module's output files byte-by-byte.
In addition, if a system designer aims to assemble modules into a system with a more complex network of inputs and outputs and to employ a specific control regimen to govern the exact sequence of activities within the network of interacting modules, he is forced to resort to explicit low level programming instructions; current programming environments, including existing shells and high level languages, provide no support for such goals.
Another limitation of existing programming technology is that programming frameworks which are applicable to object-oriented or message-passing systems, in spite of providing a self-contained mechanism for implementing message-passing between objects, are incapable of allowing object sets to be composed into a module or the combination of modules with other modules in different programming frameworks in order to build heterogenous systems. For instance, it is not possible to incorporate into a SMALLTALK program a pre-existing computer program that is not a collection of SMALLTALK objects. Moreover, existing programming languages such as SMALLTALK do not provide general purpose techniques for expressing the connections among modules that are necessary to specify the system design. This constitutes a major deficiency in the building of complex systems where the structure and connection topology can make the difference between practical and excessive amounts of message-passing communication.
Accordingly, in order to efficiently build complex systems, there is a need for a flexible computing architecture for developing applications by the assembly of collections of modules into systems of parts that interact via message-passing, where the functionality of each module is independent of its implementation, and each module can be composed of an assembly of modules in a recursive fashion.
Computer systems are being called upon to perform increasingly complex planning and design tasks. In many applications the design process is so complex that a valid plan or design is obtained only after considerable human effort and machine time, and it is nearly impossible to provide a plan or design that can handle all anticipated situations of interest. Consequently, it has been necessary to provide a new plan or design when the overall situation has changed so far as to render the original design potentially invalid as a result of certain underlying or critical assumptions of the plan becomming no longer true.
Accordingly, to enhance the reliability of designs or plans and to facilitate the provision of a new design or plan to reflect changing conditions, there is a need for a novel computer system for testing designs or plans and modifying plans or designs so that a valid design or plan will be available at the time of implementing the plan or design.